home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / gdb / dist / remote-multi.shar / remote_gutils.c next >
Encoding:
C/C++ Source or Header  |  1989-09-20  |  9.1 KB  |  420 lines
  1. /* General utility routines for the remote server for GDB, the GNU debugger.
  2.    Copyright (C) 1986, 1989 Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  6. GDB is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GDB is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GDB; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include <stdio.h>
  21. #include <sys/ioctl.h>
  22. #include "defs.h"
  23.  
  24. void error ();
  25. void fatal ();
  26.  
  27. /* Chain of cleanup actions established with make_cleanup,
  28.    to be executed if an error happens.  */
  29.  
  30. static struct cleanup *cleanup_chain;
  31.  
  32. /* Nonzero means a quit has been requested.  */
  33.  
  34. int quit_flag;
  35.  
  36. /* Nonzero means quit immediately if Control-C is typed now,
  37.    rather than waiting until QUIT is executed.  */
  38.  
  39. int immediate_quit;
  40.  
  41. /* Add a new cleanup to the cleanup_chain,
  42.    and return the previous chain pointer
  43.    to be passed later to do_cleanups or discard_cleanups.
  44.    Args are FUNCTION to clean up with, and ARG to pass to it.  */
  45.  
  46. struct cleanup *
  47. make_cleanup (function, arg)
  48.      void (*function) ();
  49.      int arg;
  50. {
  51.   register struct cleanup *new
  52.     = (struct cleanup *) xmalloc (sizeof (struct cleanup));
  53.   register struct cleanup *old_chain = cleanup_chain;
  54.  
  55.   new->next = cleanup_chain;
  56.   new->function = function;
  57.   new->arg = arg;
  58.   cleanup_chain = new;
  59.  
  60.   return old_chain;
  61. }
  62.  
  63. /* Discard cleanups and do the actions they describe
  64.    until we get back to the point OLD_CHAIN in the cleanup_chain.  */
  65.  
  66. void
  67. do_cleanups (old_chain)
  68.      register struct cleanup *old_chain;
  69. {
  70.   register struct cleanup *ptr;
  71.   while ((ptr = cleanup_chain) != old_chain)
  72.     {
  73.       (*ptr->function) (ptr->arg);
  74.       cleanup_chain = ptr->next;
  75.       free (ptr);
  76.     }
  77. }
  78.  
  79. /* Discard cleanups, not doing the actions they describe,
  80.    until we get back to the point OLD_CHAIN in the cleanup_chain.  */
  81.  
  82. void
  83. discard_cleanups (old_chain)
  84.      register struct cleanup *old_chain;
  85. {
  86.   register struct cleanup *ptr;
  87.   while ((ptr = cleanup_chain) != old_chain)
  88.     {
  89.       cleanup_chain = ptr->next;
  90.       free (ptr);
  91.     }
  92. }
  93.  
  94. /* This function is useful for cleanups.
  95.    Do
  96.  
  97.      foo = xmalloc (...);
  98.      old_chain = make_cleanup (free_current_contents, &foo);
  99.  
  100.    to arrange to free the object thus allocated.  */
  101.  
  102. void
  103. free_current_contents (location)
  104.      char **location;
  105. {
  106.   free (*location);
  107. }
  108.  
  109. /* Generally useful subroutines used throughout the program.  */
  110.  
  111. /* Like malloc but get error if no storage available.  */
  112.  
  113. char *
  114. xmalloc (size)
  115.      long size;
  116. {
  117.   register char *val = (char *) malloc (size);
  118.   if (!val)
  119.     fatal ("virtual memory exhausted.", 0);
  120.   return val;
  121. }
  122.  
  123. /* Like realloc but get error if no storage available.  */
  124.  
  125. char *
  126. xrealloc (ptr, size)
  127.      char *ptr;
  128.      long size;
  129. {
  130.   register char *val = (char *) realloc (ptr, size);
  131.   if (!val)
  132.     fatal ("virtual memory exhausted.", 0);
  133.   return val;
  134. }
  135.  
  136. /* Print the system error message for errno, and also mention STRING
  137.    as the file name for which the error was encountered.
  138.    Then return to command level.  */
  139.  
  140. void
  141. perror_with_name (string)
  142.      char *string;
  143. {
  144.   extern int sys_nerr;
  145.   extern char *sys_errlist[];
  146.   extern int errno;
  147.   char *err;
  148.   char *combined;
  149.  
  150.   if (errno < sys_nerr)
  151.     err = sys_errlist[errno];
  152.   else
  153.     err = "unknown error";
  154.  
  155.   combined = (char *) alloca (strlen (err) + strlen (string) + 3);
  156.   strcpy (combined, string);
  157.   strcat (combined, ": ");
  158.   strcat (combined, err);
  159.  
  160.   error ("%s.", combined);
  161. }
  162.  
  163. /* Print the system error message for ERRCODE, and also mention STRING
  164.    as the file name for which the error was encountered.  */
  165.  
  166. void
  167. print_sys_errmsg (string, errcode)
  168.      char *string;
  169.      int errcode;
  170. {
  171.   extern int sys_nerr;
  172.   extern char *sys_errlist[];
  173.   char *err;
  174.   char *combined;
  175.  
  176.   if (errcode < sys_nerr)
  177.     err = sys_errlist[errcode];
  178.   else
  179.     err = "unknown error";
  180.  
  181.   combined = (char *) alloca (strlen (err) + strlen (string) + 3);
  182.   strcpy (combined, string);
  183.   strcat (combined, ": ");
  184.   strcat (combined, err);
  185.  
  186.   printf ("%s.\n", combined);
  187. }
  188.  
  189. void
  190. quit ()
  191. {
  192.   fflush (stdout);
  193.   ioctl (fileno (stdout), TIOCFLUSH, 0);
  194.   error ("Quit");
  195. }
  196.  
  197. /* Control C comes here */
  198.  
  199. void
  200. request_quit ()
  201. {
  202.   quit_flag = 1;
  203.   if (immediate_quit)
  204.     quit ();
  205. }
  206.  
  207. /* Print an error message and return to command level.
  208.    STRING is the error message, used as a fprintf string,
  209.    and ARG is passed as an argument to it.  */
  210.  
  211. void
  212. error (string, arg1, arg2, arg3)
  213.      char *string;
  214.      int arg1, arg2, arg3;
  215. {
  216.   fflush (stdout);
  217.   fprintf (stderr, string, arg1, arg2, arg3);
  218.   fprintf (stderr, "\n");
  219.   /************return_to_top_level ();************/ 
  220. }
  221.  
  222. /* Print an error message and exit reporting failure.
  223.    This is for a error that we cannot continue from.
  224.    STRING and ARG are passed to fprintf.  */
  225.  
  226. void
  227. fatal (string, arg)
  228.      char *string;
  229.      int arg;
  230. {
  231.   fprintf (stderr, "gdb: ");
  232.   fprintf (stderr, string, arg);
  233.   fprintf (stderr, "\n");
  234.   exit (1);
  235. }
  236.  
  237. /* Make a copy of the string at PTR with SIZE characters
  238.    (and add a null character at the end in the copy).
  239.    Uses malloc to get the space.  Returns the address of the copy.  */
  240.  
  241. char *
  242. savestring (ptr, size)
  243.      char *ptr;
  244.      int size;
  245. {
  246.   register char *p = (char *) xmalloc (size + 1);
  247.   bcopy (ptr, p, size);
  248.   p[size] = 0;
  249.   return p;
  250. }
  251.  
  252. char *
  253. concat (s1, s2, s3)
  254.      char *s1, *s2, *s3;
  255. {
  256.   register int len = strlen (s1) + strlen (s2) + strlen (s3) + 1;
  257.   register char *val = (char *) xmalloc (len);
  258.   strcpy (val, s1);
  259.   strcat (val, s2);
  260.   strcat (val, s3);
  261.   return val;
  262. }
  263.  
  264. void
  265. print_spaces (n, file)
  266.      register int n;
  267.      register FILE *file;
  268. {
  269.   while (n-- > 0)
  270.     fputc (' ', file);
  271. }
  272.  
  273. /* Ask user a y-or-n question and return 1 iff answer is yes.
  274.    Takes three args which are given to printf to print the question.
  275.    The first, a control string, should end in "? ".
  276.    It should not say how to answer, because we do that.  */
  277.  
  278. int
  279. query (ctlstr, arg1, arg2)
  280.      char *ctlstr;
  281. {
  282.   register int answer;
  283.  
  284.   /* Automatically answer "yes" if input is not from a terminal.  */
  285.   /***********if (!input_from_terminal_p ())
  286.     return 1; *************************/ 
  287.  
  288.   while (1)
  289.     {
  290.       printf (ctlstr, arg1, arg2);
  291.       printf ("(y or n) ");
  292.       fflush (stdout);
  293.       answer = fgetc (stdin);
  294.       clearerr (stdin);        /* in case of C-d */
  295.       if (answer != '\n')
  296.     while (fgetc (stdin) != '\n') clearerr (stdin);
  297.       if (answer >= 'a')
  298.     answer -= 040;
  299.       if (answer == 'Y')
  300.     return 1;
  301.       if (answer == 'N')
  302.     return 0;
  303.       printf ("Please answer y or n.\n");
  304.     }
  305. }
  306.  
  307. /* Parse a C escape sequence.  STRING_PTR points to a variable
  308.    containing a pointer to the string to parse.  That pointer
  309.    is updated past the characters we use.  The value of the
  310.    escape sequence is returned.
  311.  
  312.    A negative value means the sequence \ newline was seen,
  313.    which is supposed to be equivalent to nothing at all.
  314.  
  315.    If \ is followed by a null character, we return a negative
  316.    value and leave the string pointer pointing at the null character.
  317.  
  318.    If \ is followed by 000, we return 0 and leave the string pointer
  319.    after the zeros.  A value of 0 does not mean end of string.  */
  320.  
  321. int
  322. parse_escape (string_ptr)
  323.      char **string_ptr;
  324. {
  325.   register int c = *(*string_ptr)++;
  326.   switch (c)
  327.     {
  328.     case 'a':
  329.       return '\a';
  330.     case 'b':
  331.       return '\b';
  332.     case 'e':
  333.       return 033;
  334.     case 'f':
  335.       return '\f';
  336.     case 'n':
  337.       return '\n';
  338.     case 'r':
  339.       return '\r';
  340.     case 't':
  341.       return '\t';
  342.     case 'v':
  343.       return '\v';
  344.     case '\n':
  345.       return -2;
  346.     case 0:
  347.       (*string_ptr)--;
  348.       return 0;
  349.     case '^':
  350.       c = *(*string_ptr)++;
  351.       if (c == '\\')
  352.     c = parse_escape (string_ptr);
  353.       if (c == '?')
  354.     return 0177;
  355.       return (c & 0200) | (c & 037);
  356.       
  357.     case '0':
  358.     case '1':
  359.     case '2':
  360.     case '3':
  361.     case '4':
  362.     case '5':
  363.     case '6':
  364.     case '7':
  365.       {
  366.     register int i = c - '0';
  367.     register int count = 0;
  368.     while (++count < 3)
  369.       {
  370.         if ((c = *(*string_ptr)++) >= '0' && c <= '7')
  371.           {
  372.         i *= 8;
  373.         i += c - '0';
  374.           }
  375.         else
  376.           {
  377.         (*string_ptr)--;
  378.         break;
  379.           }
  380.       }
  381.     return i;
  382.       }
  383.     default:
  384.       return c;
  385.     }
  386. }
  387.  
  388. void
  389. printchar (ch, stream)
  390.      unsigned char ch;
  391.      FILE *stream;
  392. {
  393.   register int c = ch;
  394.   if (c < 040 || c >= 0177)
  395.     {
  396.       if (c == '\n')
  397.     fprintf (stream, "\\n");
  398.       else if (c == '\b')
  399.     fprintf (stream, "\\b");
  400.       else if (c == '\t')
  401.     fprintf (stream, "\\t");
  402.       else if (c == '\f')
  403.     fprintf (stream, "\\f");
  404.       else if (c == '\r')
  405.     fprintf (stream, "\\r");
  406.       else if (c == 033)
  407.     fprintf (stream, "\\e");
  408.       else if (c == '\a')
  409.     fprintf (stream, "\\a");
  410.       else
  411.     fprintf (stream, "\\%03o", c);
  412.     }
  413.   else
  414.     {
  415.       if (c == '\\' || c == '"' || c == '\'')
  416.     fputc ('\\', stream);
  417.       fputc (c, stream);
  418.     }
  419. }
  420.